package sv.com.action.comun;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.naming.InitialContext;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.ezmorph.bean.MorphDynaBean;
import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporter;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.export.JRPdfExporter;
import net.sf.jasperreports.engine.export.JRXlsExporter;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;

import sv.com.objetos.auxiliares.Cadena;
import sv.com.objetos.auxiliares.Fecha;
import sv.com.objetos.auxiliares.UsuarioLogueado;
import sv.com.objetos.jqgrid.CamposJQGrid;
import sv.com.servicio.generico.DaoGenerico;

import ar.com.fdvs.dj.core.DynamicJasperHelper;
import ar.com.fdvs.dj.core.layout.ClassicLayoutManager;
import ar.com.fdvs.dj.domain.DynamicReport;
import javax.naming.Context;
import com.opensymphony.xwork2.ActionSupport;

public class ComunAction extends ActionSupport implements
ServletRequestAware,ServletResponseAware {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private HttpServletRequest request;
	private HttpServletResponse response;
	public static final String TIPO_MANTO="oper";
	public static final int AGREGAR=1;
	public static final int CONSULTAR=2;
	public static final int MODIFICAR=3;
	public static final int ELIMINAR=4;
	
	public static final String AGR="add";
	public static final String CONS="filter";
	public static final String MOD="edit";
	public static final String ELI="del";
	public CamposJQGrid camposJQGrid = new CamposJQGrid();
	public String oper;
	public String ajax;
	public String formato;
	
	public String usuarioLogueado;
	public String rolLogueado;
	
	public DaoGenerico servicioGenerico;
	
	public void prepare() throws Exception {
		
	}
	
	public int traducirOper(String oper){
		if(oper.equals("add")) return AGREGAR;
		else if(oper.equals("edit")) return MODIFICAR;
		else if(oper.equals("del")) return ELIMINAR;
		else return 0;
	}
	
	public String getFormato() {
		return formato;
	}

	public void setFormato(String formato) {
		this.formato = formato;
	}

	/*INICIO enviar objeto al Cliente como Json*/
	public void enviarJsonNavegador( JSONObject jo){
		try {
			response.setCharacterEncoding("UTF-8");
			response.getWriter().println(jo);
			response.getWriter().flush();
			response.getWriter().close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public void enviarJsonNavegador( JSONArray jao){
		try {
			response.setCharacterEncoding("UTF-8");
			response.getWriter().println(jao);
			response.getWriter().flush();
			response.getWriter().close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	/*FIN enviar objeto al Cliente como Json*/
	
	/*INICIO campos Request y Response de la Accion*/
	
	/*FIN campos Request y Response de la Accion*/
	
	/*INICIO Campos de interaccion Cliente JQGrid con la Accion (servidor)*/
	public Boolean get_search() {
		return camposJQGrid.get_search();
	}

	public String getId() {
		return camposJQGrid.getId();
	}

	public String getNd() {
		return camposJQGrid.getNd();
	}

	public Integer getPage() {
		return camposJQGrid.getPage();
	}

	public Integer getRows() {
		return camposJQGrid.getRows();
	}

	public String getSearchField() {
		return camposJQGrid.getSearchField();
	}

	public String getSearchString() {
		return camposJQGrid.getSearchString();
	}

	public String getSidx() {
		return camposJQGrid.getSidx();
	}

	public String getSord() {
		return camposJQGrid.getSord();
	}

	public void set_search(Boolean _search) {
		camposJQGrid.set_search(_search);
	}

	public void setId(String id) {
		camposJQGrid.setId(id);
	}

	public void setNd(String nd) {
		camposJQGrid.setNd(nd);
	}

	public void setPage(Integer page) {
		camposJQGrid.setPage(page);
	}

	public void setRows(Integer rows) {
		camposJQGrid.setRows(rows);
	}

	public void setSearchField(String searchField) {
		camposJQGrid.setSearchField(searchField);
	}

	public void setSearchString(String searchString) {
		camposJQGrid.setSearchString(searchString);
	}

	public void setSidx(String sidx) {
		camposJQGrid.setSidx(sidx);
	}

	public void setSord(String sord) {
		camposJQGrid.setSord(sord);
	}
	/*FIN Campos de interaccion Cliente JQGrid con la Accion (servidor)*/

	public CamposJQGrid getCamposJQGrid() {
		return camposJQGrid;
	}

	public void setCamposJQGrid(CamposJQGrid camposJQGrid) {
		this.camposJQGrid = camposJQGrid;
	}

	public String getFilters() {
		List<MorphDynaBean> reglas=camposJQGrid.getFilters().getRules();
		StringBuilder sb=new StringBuilder();
		int i=0;
		camposJQGrid.setValoresBusqueda(new ArrayList<Object>());
		for(MorphDynaBean regla:reglas){
			if(i++>0) sb.append(" "+getGroupOp()+" ");
			if(traducir(regla.get("op")).equals(" like ")){
				sb.append("upper(c."+cambiarAPunto(regla.get("field"))).append(")")
				.append(traducir(regla.get("op")))
				.append("? ");
				camposJQGrid.getValoresBusqueda().add(Cadena.retornarCadenaBusqueda((String)regla.get("data")));
			}else{
				sb.append("c."+cambiarAPunto(regla.get("field")))
				.append(traducir(regla.get("op")))
				.append("? ");
				camposJQGrid.getValoresBusqueda().add(regla.get("data"));
			}
			
		}
		if(!Cadena.vacio(getSidx()))
			sb.append(" order by "+cambiarAPunto(getSidx())+" "+getSord());
		return sb.toString();
	}
	
	
    public void enviarANavegador(HttpServletResponse response,String textoRespuesta) throws IOException{
        response.setCharacterEncoding("iso-8859-1");
        response.getWriter().println(textoRespuesta);
        response.getWriter().flush();
        response.getWriter().close();
    }

	
	public void enviarANavegador(HttpServletResponse response, ByteArrayOutputStream baos) throws IOException {
		ServletOutputStream sos=response.getOutputStream();
		sos.write(baos.toByteArray());
		sos.flush();
		sos.close();
	}
	
	public HashMap<String,Object> obtenerFiltros(){
		HashMap<String, Object> filtros=new HashMap<String, Object>();
		ArrayList<String> propiedades=new ArrayList<String>();
		ArrayList<Object> valores=new ArrayList<Object>();
		ArrayList<String> tiposConsulta=new ArrayList<String>();

		List<MorphDynaBean> reglas=camposJQGrid.getFilters().getRules();
		for(MorphDynaBean regla:reglas){
			propiedades.add(cambiarAPunto(regla.get("field")));
			valores.add(regla.get("data"));
			tiposConsulta.add(traducir(regla.get("op")));
		}
		filtros.put("propiedades", propiedades);
		filtros.put("valores", valores);
		filtros.put("tiposConsulta", tiposConsulta);
		return filtros;
	}
	
	public static String cambiarAPunto(Object cadena){
		return ((String)cadena).replaceAll("_", ".");
	}
	
	public static String traducir(Object object){
		if(object.equals("eq")) return " = ";
		else if(object.equals("cn")) return " like ";
		return "sin-definir";
	}
	
	public void setFilters(String filters) {
		camposJQGrid.setFilters(filters);
		
		
	}

	public ArrayList<Object> getValoresBusqueda() {
		return camposJQGrid.getValoresBusqueda();
	}

	public void setValoresBusqueda(ArrayList<Object> valoresBusqueda) {
		camposJQGrid.setValoresBusqueda(valoresBusqueda);
	}

	public String getOper() {
		return oper;
	}

	public void setOper(String oper) {
		this.oper = oper;
	}
	
	public String getGroupOp() {
		return camposJQGrid.getFilters().getGroupOp();
	}

	public void setGroupOp(String groupOp) {
		camposJQGrid.getFilters().setGroupOp(groupOp);
	}

	public String getAjax() {
		return ajax;
	}

	public void setAjax(String ajax) {
		this.ajax = ajax;
	}

//	/*usuario logueado*/
//	@SuppressWarnings("unchecked")
//	public void subirDatosUsuarioLogueado(Usuario us){
//		//getRequest().getSession().setAttribute(Constantes.ROL_USUARIO_LOGUEADO, us.getTipoUsuario().getIdTipoUsuario().toString());
//		
//		Map session = ActionContext.getContext().getSession();
//	    session.put(Constantes.USUARIO_LOGUEADO,us);
//		session.put(Constantes.ROL_USUARIO_LOGUEADO, us.getTipoUsuario().getIdTipoUsuario().toString());
//	    
//		setUsuarioLogueado(us.getPrimerNombre());
//		setRolLogueado(us.getTipoUsuario().getTipoUsuario());
//	}
//	
//	@SuppressWarnings("unchecked")
//	public Usuario obtenerUsuarioLogueado(){
//		Map session = ActionContext.getContext().getSession();
//	    return (Usuario)session.get(Constantes.USUARIO_LOGUEADO);
//	}
//	
	public String getUsuarioLogueado() {
		return usuarioLogueado;
	}
	public void setUsuarioLogueado(String usuarioLogueado) {
		this.usuarioLogueado = usuarioLogueado;
	}
	public String getRolLogueado() {
		return rolLogueado;
	}
	public void setRolLogueado(String rolLogueado) {
		this.rolLogueado = rolLogueado;
	}
	/*fin usuario logueado*/

	/*INICIO SERVICIO GENERICO*/
	public DaoGenerico getServicioGenerico() {
		return servicioGenerico;
	}

	public void setServicioGenerico(DaoGenerico servicioGenerico) {
		this.servicioGenerico = servicioGenerico;
	}
	/*FIN SERVICIO GENERICO*/
	
	
	/*metodos comunes*/
	@SuppressWarnings("unchecked")
	public void cargarCombo(String tablaMapeada){
		List profesores= servicioGenerico.realizarBusqueda("from "+tablaMapeada, null);
		JSONArray jao= JSONArray.fromObject(profesores);
		enviarJsonNavegador(jao);
	}
	
	public void enviarMensajeJson(String mensaje){
		HashMap<String, String>envio = new HashMap<String, String>();
		envio.put("mensaje", Fecha.fechaActualCompleta()+" "+mensaje);
		JSONObject jo = JSONObject.fromObject(envio);
		enviarJsonNavegador(jo);
	}
	
	public void enviarMensajeJson(String mensaje, String tipo){
		HashMap<String, String>envio = new HashMap<String, String>();
		envio.put("mensaje", Fecha.fechaActualCompleta()+" "+mensaje);
		envio.put("tipo", tipo);
		JSONObject jo = JSONObject.fromObject(envio);
		enviarJsonNavegador(jo);
	}
	
	
	  public static void enviarMensajeStatic(String mensaje, HttpServletResponse response){
          String valores[]=mensaje.split("~");
          HashMap<String, String> hm=new HashMap<String, String>();
          if(valores[0].equals("error")){
        	  hm.put("error", "1");
        	  hm.put("mensaje", valores[1]);
          }else if(valores[0].equals("exito")){
        	  hm.put("exito", "1");
        	  hm.put("mensaje", valores[1]);
          }
         // if(valores.length==2) hm.put("funcionAEjecutar", valores[1]);
          JSONObject jo=JSONObject.fromObject(hm);
          enviarJsonNavegadorStatic(response, jo);
}

	
	   public static void enviarJsonNavegadorStatic(HttpServletResponse response, JSONObject jo){
           try {
               response.setCharacterEncoding("iso-8859-1");
               response.getWriter().println(jo);
               response.getWriter().flush();
               response.getWriter().close();
           } catch (IOException e) {
               e.printStackTrace();
           }

}

	  
	
	  public void generarReporteDeObjetos(String tituloReporte, DynamicReport dr, List lista, String formatoExportacion, HttpServletResponse response) throws Exception{
	        JRDataSource jrds = new JRBeanCollectionDataSource(lista);
	        JasperPrint jp = DynamicJasperHelper.generateJasperPrint(dr,
	        new ClassicLayoutManager(), jrds);

	        ByteArrayOutputStream baos = new ByteArrayOutputStream();
	        enviarReporteANavegador(response, formatoExportacion, tituloReporte, jp, baos);
	    }
	  
	  public void enviarReporteANavegador(HttpServletResponse response,
		        String formatoExportacion, String tituloReporte, JasperPrint jp,
		        ByteArrayOutputStream baos) throws JRException, IOException {
		        editarResponse(response,formatoExportacion,tituloReporte);
		        ejecutarExportacion(jp, baos, formatoExportacion);
		        enviarANavegador(response,baos);
		    }
	  
	  public void enviarTxtANavegador(HttpServletResponse response,
		        String formatoExportacion, String tituloReporte,
		        ByteArrayOutputStream baos) throws  IOException {
		        editarResponse(response,formatoExportacion,tituloReporte);		        
		        enviarANavegador(response,baos);
		    }
	  
	  
	    public void editarResponse(HttpServletResponse response, String formato, String nombreArchivo){
	        response.setHeader("Cache-Control", "private");
	        response.setHeader("Pragma", "Cache");
	        if(formato.equals("PDF")){
	            response.setContentType("application/pdf;");
	            response.setHeader("content-Disposition", "attachment;filename="+nombreArchivo+"."+formato);
	        } else if(formato.equals("XLS")){
	            response.setContentType("application/vnd.ms-excel");
	            response.setHeader("content-Disposition", "attachment;filename="+nombreArchivo+"."+formato);
	        }else if(formato.equals("TXT")){
	        	response.setContentType("application/plain");
	            response.setHeader("content-Disposition", "attachment;filename="+nombreArchivo+"."+formato);
	            //response.setContentType("application/octet-stream");
	            // response.setHeader("Content-Disposition","inline; filename=\""+nombreArchivo+"\"");
	        	//response.setHeader("Content-Disposition","attachment;filename="+nombreArchivo);
	        }
	    }
	    
	    public void ejecutarExportacion(JasperPrint jp, ByteArrayOutputStream baos, String formatoExportacion) throws JRException {
	        if(formatoExportacion.equals("PDF")){
	            JRPdfExporter export = new JRPdfExporter();
	            export.setParameter(JRExporterParameter.JASPER_PRINT,jp);
	            export.setParameter(JRExporterParameter.OUTPUT_STREAM,baos);
	            export.exportReport();
	        }
	        else if(formatoExportacion.equals("XLS")){
	            JRXlsExporter export = new JRXlsExporter();
	            export.setParameter(JRExporterParameter.JASPER_PRINT,jp);
	            export.setParameter(JRExporterParameter.OUTPUT_STREAM,baos);
	            export.exportReport();
	        }
	    }

//	    public void generarReporteIReport(String formato, String arcPdf, String arcJasper, HashMap parametros) throws Exception {
//	       Context cont = new InitialContext();
//	       JasperPrint impresion = JasperFillManager.fillReport(arcJasper, parametros, ((DataSource) cont.lookup("prom_jndi")).getConnection());
//	       JRExporter exporter = new JRPdfExporter();
//	       OutputStream os = getServletResponse().getOutputStream();
//	       exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, arcPdf);
//	       exporter.setParameter(JRExporterParameter.JASPER_PRINT, impresion);
//	       exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, os);
//	       editarResponse(getServletResponse(), formato, arcPdf);
//	       exporter.exportReport();
//	       os.flush();
//	       os.close();
//	    }
	/*fin metodos comunes*/

    /**
    *
    * @return the servletRequest
    */
   public HttpServletRequest getServletRequest() {
       return request;
   }

   /**
    * @param servletRequest the servletRequest to set
    */
   public void setServletRequest(HttpServletRequest servletRequest) {
       this.request = servletRequest;
   }

   /**
    * @return the servletResponse
    */
   public HttpServletResponse getServletResponse() {
       return response;
   }

   /**
    * @param servletResponse the servletResponse to set
    */
   public void setServletResponse(HttpServletResponse servletResponse) {
       this.response = servletResponse;
   }
   
   public UsuarioLogueado obtenerUsuarioLogueado(HttpServletRequest request){
       return(UsuarioLogueado)request.getSession().getAttribute("usuario");

   }
}